1 // The template and inlines for the -*- C++ -*- complex number classes.
3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
4 // Free Software Foundation, Inc.
6 // This file is part of the GNU ISO C++ Library. This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 2, or (at your option)
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
17 // You should have received a copy of the GNU General Public License along
18 // with this library; see the file COPYING. If not, write to the Free
19 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction. Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License. This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
32 // ISO C++ 14882: 26.2 Complex Numbers
33 // Note: this is not a conforming implementation.
34 // Initially implemented by Ulrich Drepper <drepper@cygnus.com>
35 // Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
39 * This is a Standard C++ Library header.
42 #ifndef _GLIBCXX_COMPLEX
43 #define _GLIBCXX_COMPLEX 1
45 #pragma GCC system_header
47 #include <bits/c++config.h>
48 #include <bits/cpp_type_traits.h>
54 // Forward declarations.
55 template<typename _Tp> class complex;
56 template<> class complex<float>;
57 template<> class complex<double>;
58 template<> class complex<long double>;
60 /// Return magnitude of @a z.
61 template<typename _Tp> _Tp abs(const complex<_Tp>&);
62 /// Return phase angle of @a z.
63 template<typename _Tp> _Tp arg(const complex<_Tp>&);
64 /// Return @a z magnitude squared.
65 template<typename _Tp> _Tp norm(const complex<_Tp>&);
67 /// Return complex conjugate of @a z.
68 template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
69 /// Return complex with magnitude @a rho and angle @a theta.
70 template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
73 /// Return complex cosine of @a z.
74 template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
75 /// Return complex hyperbolic cosine of @a z.
76 template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
77 /// Return complex base e exponential of @a z.
78 template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
79 /// Return complex natural logarithm of @a z.
80 template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
81 /// Return complex base 10 logarithm of @a z.
82 template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
83 /// Return complex cosine of @a z.
84 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
85 /// Return @a x to the @a y'th power.
86 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
87 /// Return @a x to the @a y'th power.
88 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
90 /// Return @a x to the @a y'th power.
91 template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
92 /// Return complex sine of @a z.
93 template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
94 /// Return complex hyperbolic sine of @a z.
95 template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
96 /// Return complex square root of @a z.
97 template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
98 /// Return complex tangent of @a z.
99 template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
100 /// Return complex hyperbolic tangent of @a z.
101 template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
105 // 26.2.2 Primary template class complex
107 * Template to represent complex numbers.
109 * Specializations for float, double, and long double are part of the
110 * library. Results with any other type are not guaranteed.
112 * @param Tp Type of real and imaginary values.
114 template<typename _Tp>
118 typedef _Tp value_type;
120 /// Default constructor. First parameter is x, second parameter is y.
121 /// Unspecified parameters default to 0.
122 complex(const _Tp& = _Tp(), const _Tp & = _Tp());
124 // Lets the compiler synthesize the copy constructor
125 // complex (const complex<_Tp>&);
126 /// Copy constructor.
127 template<typename _Up>
128 complex(const complex<_Up>&);
130 /// Return real part of complex number.
132 /// Return real part of complex number.
133 const _Tp& real() const;
134 /// Return imaginary part of complex number.
136 /// Return imaginary part of complex number.
137 const _Tp& imag() const;
139 /// Assign this complex number to scalar @a t.
140 complex<_Tp>& operator=(const _Tp&);
141 /// Add @a t to this complex number.
142 complex<_Tp>& operator+=(const _Tp&);
143 /// Subtract @a t from this complex number.
144 complex<_Tp>& operator-=(const _Tp&);
145 /// Multiply this complex number by @a t.
146 complex<_Tp>& operator*=(const _Tp&);
147 /// Divide this complex number by @a t.
148 complex<_Tp>& operator/=(const _Tp&);
150 // Lets the compiler synthesize the
151 // copy and assignment operator
152 // complex<_Tp>& operator= (const complex<_Tp>&);
153 /// Assign this complex number to complex @a z.
154 template<typename _Up>
155 complex<_Tp>& operator=(const complex<_Up>&);
156 /// Add @a z to this complex number.
157 template<typename _Up>
158 complex<_Tp>& operator+=(const complex<_Up>&);
159 /// Subtract @a z from this complex number.
160 template<typename _Up>
161 complex<_Tp>& operator-=(const complex<_Up>&);
162 /// Multiply this complex number by @a z.
163 template<typename _Up>
164 complex<_Tp>& operator*=(const complex<_Up>&);
165 /// Divide this complex number by @a z.
166 template<typename _Up>
167 complex<_Tp>& operator/=(const complex<_Up>&);
169 const complex& __rep() const;
176 template<typename _Tp>
178 complex<_Tp>::real() { return _M_real; }
180 template<typename _Tp>
182 complex<_Tp>::real() const { return _M_real; }
184 template<typename _Tp>
186 complex<_Tp>::imag() { return _M_imag; }
188 template<typename _Tp>
190 complex<_Tp>::imag() const { return _M_imag; }
192 template<typename _Tp>
194 complex<_Tp>::complex(const _Tp& __r, const _Tp& __i)
195 : _M_real(__r), _M_imag(__i) { }
197 template<typename _Tp>
198 template<typename _Up>
200 complex<_Tp>::complex(const complex<_Up>& __z)
201 : _M_real(__z.real()), _M_imag(__z.imag()) { }
203 template<typename _Tp>
205 complex<_Tp>::operator=(const _Tp& __t)
213 template<typename _Tp>
215 complex<_Tp>::operator+=(const _Tp& __t)
222 template<typename _Tp>
224 complex<_Tp>::operator-=(const _Tp& __t)
231 template<typename _Tp>
233 complex<_Tp>::operator*=(const _Tp& __t)
241 template<typename _Tp>
243 complex<_Tp>::operator/=(const _Tp& __t)
250 template<typename _Tp>
251 template<typename _Up>
253 complex<_Tp>::operator=(const complex<_Up>& __z)
255 _M_real = __z.real();
256 _M_imag = __z.imag();
261 template<typename _Tp>
262 template<typename _Up>
264 complex<_Tp>::operator+=(const complex<_Up>& __z)
266 _M_real += __z.real();
267 _M_imag += __z.imag();
272 template<typename _Tp>
273 template<typename _Up>
275 complex<_Tp>::operator-=(const complex<_Up>& __z)
277 _M_real -= __z.real();
278 _M_imag -= __z.imag();
283 // XXX: This is a grammar school implementation.
284 template<typename _Tp>
285 template<typename _Up>
287 complex<_Tp>::operator*=(const complex<_Up>& __z)
289 const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
290 _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
296 // XXX: This is a grammar school implementation.
297 template<typename _Tp>
298 template<typename _Up>
300 complex<_Tp>::operator/=(const complex<_Up>& __z)
302 const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
303 const _Tp __n = std::norm(__z);
304 _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
309 template<typename _Tp>
310 inline const complex<_Tp>&
311 complex<_Tp>::__rep() const { return *this; }
315 /// Return new complex value @a x plus @a y.
316 template<typename _Tp>
318 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
320 complex<_Tp> __r = __x;
325 template<typename _Tp>
327 operator+(const complex<_Tp>& __x, const _Tp& __y)
329 complex<_Tp> __r = __x;
334 template<typename _Tp>
336 operator+(const _Tp& __x, const complex<_Tp>& __y)
338 complex<_Tp> __r = __y;
345 /// Return new complex value @a x minus @a y.
346 template<typename _Tp>
348 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
350 complex<_Tp> __r = __x;
355 template<typename _Tp>
357 operator-(const complex<_Tp>& __x, const _Tp& __y)
359 complex<_Tp> __r = __x;
364 template<typename _Tp>
366 operator-(const _Tp& __x, const complex<_Tp>& __y)
368 complex<_Tp> __r(__x, -__y.imag());
369 __r.real() -= __y.real();
375 /// Return new complex value @a x times @a y.
376 template<typename _Tp>
378 operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
380 complex<_Tp> __r = __x;
385 template<typename _Tp>
387 operator*(const complex<_Tp>& __x, const _Tp& __y)
389 complex<_Tp> __r = __x;
394 template<typename _Tp>
396 operator*(const _Tp& __x, const complex<_Tp>& __y)
398 complex<_Tp> __r = __y;
405 /// Return new complex value @a x divided by @a y.
406 template<typename _Tp>
408 operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
410 complex<_Tp> __r = __x;
415 template<typename _Tp>
417 operator/(const complex<_Tp>& __x, const _Tp& __y)
419 complex<_Tp> __r = __x;
424 template<typename _Tp>
426 operator/(const _Tp& __x, const complex<_Tp>& __y)
428 complex<_Tp> __r = __x;
435 template<typename _Tp>
437 operator+(const complex<_Tp>& __x)
440 /// Return complex negation of @a x.
441 template<typename _Tp>
443 operator-(const complex<_Tp>& __x)
444 { return complex<_Tp>(-__x.real(), -__x.imag()); }
447 /// Return true if @a x is equal to @a y.
448 template<typename _Tp>
450 operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
451 { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
453 template<typename _Tp>
455 operator==(const complex<_Tp>& __x, const _Tp& __y)
456 { return __x.real() == __y && __x.imag() == _Tp(); }
458 template<typename _Tp>
460 operator==(const _Tp& __x, const complex<_Tp>& __y)
461 { return __x == __y.real() && _Tp() == __y.imag(); }
465 /// Return false if @a x is equal to @a y.
466 template<typename _Tp>
468 operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
469 { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
471 template<typename _Tp>
473 operator!=(const complex<_Tp>& __x, const _Tp& __y)
474 { return __x.real() != __y || __x.imag() != _Tp(); }
476 template<typename _Tp>
478 operator!=(const _Tp& __x, const complex<_Tp>& __y)
479 { return __x != __y.real() || _Tp() != __y.imag(); }
482 /// Extraction operator for complex values.
483 template<typename _Tp, typename _CharT, class _Traits>
484 basic_istream<_CharT, _Traits>&
485 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
492 __is >> __re_x >> __ch;
495 __is >> __im_x >> __ch;
497 __x = complex<_Tp>(__re_x, __im_x);
499 __is.setstate(ios_base::failbit);
501 else if (__ch == ')')
504 __is.setstate(ios_base::failbit);
515 /// Insertion operator for complex values.
516 template<typename _Tp, typename _CharT, class _Traits>
517 basic_ostream<_CharT, _Traits>&
518 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
520 basic_ostringstream<_CharT, _Traits> __s;
521 __s.flags(__os.flags());
522 __s.imbue(__os.getloc());
523 __s.precision(__os.precision());
524 __s << '(' << __x.real() << ',' << __x.imag() << ')';
525 return __os << __s.str();
529 template<typename _Tp>
531 real(complex<_Tp>& __z)
532 { return __z.real(); }
534 template<typename _Tp>
536 real(const complex<_Tp>& __z)
537 { return __z.real(); }
539 template<typename _Tp>
541 imag(complex<_Tp>& __z)
542 { return __z.imag(); }
544 template<typename _Tp>
546 imag(const complex<_Tp>& __z)
547 { return __z.imag(); }
549 // 26.2.7/3 abs(__z): Returns the magnitude of __z.
550 template<typename _Tp>
552 __complex_abs(const complex<_Tp>& __z)
554 _Tp __x = __z.real();
555 _Tp __y = __z.imag();
556 const _Tp __s = std::max(abs(__x), abs(__y));
557 if (__s == _Tp()) // well ...
561 return __s * sqrt(__x * __x + __y * __y);
564 #if _GLIBCXX_USE_C99_COMPLEX
566 __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
569 __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
572 __complex_abs(const __complex__ long double& __z)
573 { return __builtin_cabsl(__z); }
575 template<typename _Tp>
577 abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
579 template<typename _Tp>
581 abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
585 // 26.2.7/4: arg(__z): Returns the phase angle of __z.
586 template<typename _Tp>
588 __complex_arg(const complex<_Tp>& __z)
589 { return atan2(__z.imag(), __z.real()); }
591 #if _GLIBCXX_USE_C99_COMPLEX
593 __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
596 __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
599 __complex_arg(const __complex__ long double& __z)
600 { return __builtin_cargl(__z); }
602 template<typename _Tp>
604 arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
606 template<typename _Tp>
608 arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
611 // 26.2.7/5: norm(__z) returns the squared magintude of __z.
612 // As defined, norm() is -not- a norm is the common mathematical
613 // sens used in numerics. The helper class _Norm_helper<> tries to
614 // distinguish between builtin floating point and the rest, so as
615 // to deliver an answer as close as possible to the real value.
619 template<typename _Tp>
620 static inline _Tp _S_do_it(const complex<_Tp>& __z)
622 const _Tp __x = __z.real();
623 const _Tp __y = __z.imag();
624 return __x * __x + __y * __y;
629 struct _Norm_helper<true>
631 template<typename _Tp>
632 static inline _Tp _S_do_it(const complex<_Tp>& __z)
634 _Tp __res = std::abs(__z);
635 return __res * __res;
639 template<typename _Tp>
641 norm(const complex<_Tp>& __z)
643 return _Norm_helper<__is_floating<_Tp>::__value
644 && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
647 template<typename _Tp>
649 polar(const _Tp& __rho, const _Tp& __theta)
650 { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
652 template<typename _Tp>
654 conj(const complex<_Tp>& __z)
655 { return complex<_Tp>(__z.real(), -__z.imag()); }
659 // 26.2.8/1 cos(__z): Returns the cosine of __z.
660 template<typename _Tp>
662 __complex_cos(const complex<_Tp>& __z)
664 const _Tp __x = __z.real();
665 const _Tp __y = __z.imag();
666 return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
669 #if _GLIBCXX_USE_C99_COMPLEX
670 inline __complex__ float
671 __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
673 inline __complex__ double
674 __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
676 inline __complex__ long double
677 __complex_cos(const __complex__ long double& __z)
678 { return __builtin_ccosl(__z); }
680 template<typename _Tp>
682 cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
684 template<typename _Tp>
686 cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
689 // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
690 template<typename _Tp>
692 __complex_cosh(const complex<_Tp>& __z)
694 const _Tp __x = __z.real();
695 const _Tp __y = __z.imag();
696 return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
699 #if _GLIBCXX_USE_C99_COMPLEX
700 inline __complex__ float
701 __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
703 inline __complex__ double
704 __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
706 inline __complex__ long double
707 __complex_cosh(const __complex__ long double& __z)
708 { return __builtin_ccoshl(__z); }
710 template<typename _Tp>
712 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
714 template<typename _Tp>
716 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
719 // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
720 template<typename _Tp>
722 __complex_exp(const complex<_Tp>& __z)
723 { return std::polar(exp(__z.real()), __z.imag()); }
725 #if _GLIBCXX_USE_C99_COMPLEX
726 inline __complex__ float
727 __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
729 inline __complex__ double
730 __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
732 inline __complex__ long double
733 __complex_exp(const __complex__ long double& __z)
734 { return __builtin_cexpl(__z); }
736 template<typename _Tp>
738 exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
740 template<typename _Tp>
742 exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
745 // 26.2.8/5 log(__z): Reurns the natural complex logaritm of __z.
746 // The branch cut is along the negative axis.
747 template<typename _Tp>
749 __complex_log(const complex<_Tp>& __z)
750 { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
752 #if _GLIBCXX_USE_C99_COMPLEX
753 inline __complex__ float
754 __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
756 inline __complex__ double
757 __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
759 inline __complex__ long double
760 __complex_log(const __complex__ long double& __z)
761 { return __builtin_clogl(__z); }
763 template<typename _Tp>
765 log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
767 template<typename _Tp>
769 log(const complex<_Tp>& __z) { return __complex_log(__z); }
772 template<typename _Tp>
774 log10(const complex<_Tp>& __z)
775 { return std::log(__z) / log(_Tp(10.0)); }
777 // 26.2.8/10 sin(__z): Returns the sine of __z.
778 template<typename _Tp>
780 __complex_sin(const complex<_Tp>& __z)
782 const _Tp __x = __z.real();
783 const _Tp __y = __z.imag();
784 return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
787 #if _GLIBCXX_USE_C99_COMPLEX
788 inline __complex__ float
789 __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
791 inline __complex__ double
792 __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
794 inline __complex__ long double
795 __complex_sin(const __complex__ long double& __z)
796 { return __builtin_csinl(__z); }
798 template<typename _Tp>
800 sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
802 template<typename _Tp>
804 sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
807 // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
808 template<typename _Tp>
810 __complex_sinh(const complex<_Tp>& __z)
812 const _Tp __x = __z.real();
813 const _Tp __y = __z.imag();
814 return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
817 #if _GLIBCXX_USE_C99_COMPLEX
818 inline __complex__ float
819 __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
821 inline __complex__ double
822 __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
824 inline __complex__ long double
825 __complex_sinh(const __complex__ long double& __z)
826 { return __builtin_csinhl(__z); }
828 template<typename _Tp>
830 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
832 template<typename _Tp>
834 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
837 // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
838 // The branch cut is on the negative axis.
839 template<typename _Tp>
841 __complex_sqrt(const complex<_Tp>& __z)
843 _Tp __x = __z.real();
844 _Tp __y = __z.imag();
848 _Tp __t = sqrt(abs(__y) / 2);
849 return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
853 _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
856 ? complex<_Tp>(__u, __y / __t)
857 : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
861 #if _GLIBCXX_USE_C99_COMPLEX
862 inline __complex__ float
863 __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
865 inline __complex__ double
866 __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
868 inline __complex__ long double
869 __complex_sqrt(const __complex__ long double& __z)
870 { return __builtin_csqrtl(__z); }
872 template<typename _Tp>
874 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
876 template<typename _Tp>
878 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
881 // 26.2.8/14 tan(__z): Return the complex tangent of __z.
883 template<typename _Tp>
885 __complex_tan(const complex<_Tp>& __z)
886 { return std::sin(__z) / std::cos(__z); }
888 #if _GLIBCXX_USE_C99_COMPLEX
889 inline __complex__ float
890 __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
892 inline __complex__ double
893 __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
895 inline __complex__ long double
896 __complex_tan(const __complex__ long double& __z)
897 { return __builtin_ctanl(__z); }
899 template<typename _Tp>
901 tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
903 template<typename _Tp>
905 tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
909 // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z.
911 template<typename _Tp>
913 __complex_tanh(const complex<_Tp>& __z)
914 { return std::sinh(__z) / std::cosh(__z); }
916 #if _GLIBCXX_USE_C99_COMPLEX
917 inline __complex__ float
918 __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
920 inline __complex__ double
921 __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
923 inline __complex__ long double
924 __complex_tanh(const __complex__ long double& __z)
925 { return __builtin_ctanhl(__z); }
927 template<typename _Tp>
929 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
931 template<typename _Tp>
933 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
937 // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x
938 // raised to the __y-th power. The branch
939 // cut is on the negative axis.
940 template<typename _Tp>
942 pow(const complex<_Tp>& __z, int __n)
943 { return std::__pow_helper(__z, __n); }
945 template<typename _Tp>
947 pow(const complex<_Tp>& __x, const _Tp& __y)
949 #ifndef _GLIBCXX_USE_C99_COMPLEX
953 if (__x.imag() == _Tp() && __x.real() > _Tp())
954 return pow(__x.real(), __y);
956 complex<_Tp> __t = std::log(__x);
957 return std::polar(exp(__y * __t.real()), __y * __t.imag());
960 template<typename _Tp>
962 __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
963 { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
965 #if _GLIBCXX_USE_C99_COMPLEX
966 inline __complex__ float
967 __complex_pow(__complex__ float __x, __complex__ float __y)
968 { return __builtin_cpowf(__x, __y); }
970 inline __complex__ double
971 __complex_pow(__complex__ double __x, __complex__ double __y)
972 { return __builtin_cpow(__x, __y); }
974 inline __complex__ long double
975 __complex_pow(const __complex__ long double& __x,
976 const __complex__ long double& __y)
977 { return __builtin_cpowl(__x, __y); }
979 template<typename _Tp>
981 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
982 { return __complex_pow(__x.__rep(), __y.__rep()); }
984 template<typename _Tp>
986 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
987 { return __complex_pow(__x, __y); }
990 template<typename _Tp>
992 pow(const _Tp& __x, const complex<_Tp>& __y)
994 return __x > _Tp() ? std::polar(pow(__x, __y.real()),
995 __y.imag() * log(__x))
996 : std::pow(complex<_Tp>(__x, _Tp()), __y);
999 // 26.2.3 complex specializations
1000 // complex<float> specialization
1002 struct complex<float>
1004 typedef float value_type;
1005 typedef __complex__ float _ComplexT;
1007 complex(_ComplexT __z) : _M_value(__z) { }
1009 complex(float = 0.0f, float = 0.0f);
1011 explicit complex(const complex<double>&);
1012 explicit complex(const complex<long double>&);
1015 const float& real() const;
1017 const float& imag() const;
1019 complex<float>& operator=(float);
1020 complex<float>& operator+=(float);
1021 complex<float>& operator-=(float);
1022 complex<float>& operator*=(float);
1023 complex<float>& operator/=(float);
1025 // Let's the compiler synthetize the copy and assignment
1026 // operator. It always does a pretty good job.
1027 // complex& operator= (const complex&);
1028 template<typename _Tp>
1029 complex<float>&operator=(const complex<_Tp>&);
1030 template<typename _Tp>
1031 complex<float>& operator+=(const complex<_Tp>&);
1033 complex<float>& operator-=(const complex<_Tp>&);
1035 complex<float>& operator*=(const complex<_Tp>&);
1037 complex<float>&operator/=(const complex<_Tp>&);
1039 const _ComplexT& __rep() const { return _M_value; }
1046 complex<float>::real()
1047 { return __real__ _M_value; }
1050 complex<float>::real() const
1051 { return __real__ _M_value; }
1054 complex<float>::imag()
1055 { return __imag__ _M_value; }
1058 complex<float>::imag() const
1059 { return __imag__ _M_value; }
1062 complex<float>::complex(float r, float i)
1064 __real__ _M_value = r;
1065 __imag__ _M_value = i;
1068 inline complex<float>&
1069 complex<float>::operator=(float __f)
1071 __real__ _M_value = __f;
1072 __imag__ _M_value = 0.0f;
1076 inline complex<float>&
1077 complex<float>::operator+=(float __f)
1079 __real__ _M_value += __f;
1083 inline complex<float>&
1084 complex<float>::operator-=(float __f)
1086 __real__ _M_value -= __f;
1090 inline complex<float>&
1091 complex<float>::operator*=(float __f)
1097 inline complex<float>&
1098 complex<float>::operator/=(float __f)
1104 template<typename _Tp>
1105 inline complex<float>&
1106 complex<float>::operator=(const complex<_Tp>& __z)
1108 __real__ _M_value = __z.real();
1109 __imag__ _M_value = __z.imag();
1113 template<typename _Tp>
1114 inline complex<float>&
1115 complex<float>::operator+=(const complex<_Tp>& __z)
1117 __real__ _M_value += __z.real();
1118 __imag__ _M_value += __z.imag();
1122 template<typename _Tp>
1123 inline complex<float>&
1124 complex<float>::operator-=(const complex<_Tp>& __z)
1126 __real__ _M_value -= __z.real();
1127 __imag__ _M_value -= __z.imag();
1131 template<typename _Tp>
1132 inline complex<float>&
1133 complex<float>::operator*=(const complex<_Tp>& __z)
1136 __real__ __t = __z.real();
1137 __imag__ __t = __z.imag();
1142 template<typename _Tp>
1143 inline complex<float>&
1144 complex<float>::operator/=(const complex<_Tp>& __z)
1147 __real__ __t = __z.real();
1148 __imag__ __t = __z.imag();
1153 // 26.2.3 complex specializations
1154 // complex<double> specialization
1156 struct complex<double>
1158 typedef double value_type;
1159 typedef __complex__ double _ComplexT;
1161 complex(_ComplexT __z) : _M_value(__z) { }
1163 complex(double = 0.0, double = 0.0);
1165 complex(const complex<float>&);
1166 explicit complex(const complex<long double>&);
1169 const double& real() const;
1171 const double& imag() const;
1173 complex<double>& operator=(double);
1174 complex<double>& operator+=(double);
1175 complex<double>& operator-=(double);
1176 complex<double>& operator*=(double);
1177 complex<double>& operator/=(double);
1179 // The compiler will synthetize this, efficiently.
1180 // complex& operator= (const complex&);
1181 template<typename _Tp>
1182 complex<double>& operator=(const complex<_Tp>&);
1183 template<typename _Tp>
1184 complex<double>& operator+=(const complex<_Tp>&);
1185 template<typename _Tp>
1186 complex<double>& operator-=(const complex<_Tp>&);
1187 template<typename _Tp>
1188 complex<double>& operator*=(const complex<_Tp>&);
1189 template<typename _Tp>
1190 complex<double>& operator/=(const complex<_Tp>&);
1192 const _ComplexT& __rep() const { return _M_value; }
1199 complex<double>::real()
1200 { return __real__ _M_value; }
1202 inline const double&
1203 complex<double>::real() const
1204 { return __real__ _M_value; }
1207 complex<double>::imag()
1208 { return __imag__ _M_value; }
1210 inline const double&
1211 complex<double>::imag() const
1212 { return __imag__ _M_value; }
1215 complex<double>::complex(double __r, double __i)
1217 __real__ _M_value = __r;
1218 __imag__ _M_value = __i;
1221 inline complex<double>&
1222 complex<double>::operator=(double __d)
1224 __real__ _M_value = __d;
1225 __imag__ _M_value = 0.0;
1229 inline complex<double>&
1230 complex<double>::operator+=(double __d)
1232 __real__ _M_value += __d;
1236 inline complex<double>&
1237 complex<double>::operator-=(double __d)
1239 __real__ _M_value -= __d;
1243 inline complex<double>&
1244 complex<double>::operator*=(double __d)
1250 inline complex<double>&
1251 complex<double>::operator/=(double __d)
1257 template<typename _Tp>
1258 inline complex<double>&
1259 complex<double>::operator=(const complex<_Tp>& __z)
1261 __real__ _M_value = __z.real();
1262 __imag__ _M_value = __z.imag();
1266 template<typename _Tp>
1267 inline complex<double>&
1268 complex<double>::operator+=(const complex<_Tp>& __z)
1270 __real__ _M_value += __z.real();
1271 __imag__ _M_value += __z.imag();
1275 template<typename _Tp>
1276 inline complex<double>&
1277 complex<double>::operator-=(const complex<_Tp>& __z)
1279 __real__ _M_value -= __z.real();
1280 __imag__ _M_value -= __z.imag();
1284 template<typename _Tp>
1285 inline complex<double>&
1286 complex<double>::operator*=(const complex<_Tp>& __z)
1289 __real__ __t = __z.real();
1290 __imag__ __t = __z.imag();
1295 template<typename _Tp>
1296 inline complex<double>&
1297 complex<double>::operator/=(const complex<_Tp>& __z)
1300 __real__ __t = __z.real();
1301 __imag__ __t = __z.imag();
1306 // 26.2.3 complex specializations
1307 // complex<long double> specialization
1309 struct complex<long double>
1311 typedef long double value_type;
1312 typedef __complex__ long double _ComplexT;
1314 complex(_ComplexT __z) : _M_value(__z) { }
1316 complex(long double = 0.0L, long double = 0.0L);
1318 complex(const complex<float>&);
1319 complex(const complex<double>&);
1321 long double& real();
1322 const long double& real() const;
1323 long double& imag();
1324 const long double& imag() const;
1326 complex<long double>& operator= (long double);
1327 complex<long double>& operator+= (long double);
1328 complex<long double>& operator-= (long double);
1329 complex<long double>& operator*= (long double);
1330 complex<long double>& operator/= (long double);
1332 // The compiler knows how to do this efficiently
1333 // complex& operator= (const complex&);
1334 template<typename _Tp>
1335 complex<long double>& operator=(const complex<_Tp>&);
1336 template<typename _Tp>
1337 complex<long double>& operator+=(const complex<_Tp>&);
1338 template<typename _Tp>
1339 complex<long double>& operator-=(const complex<_Tp>&);
1340 template<typename _Tp>
1341 complex<long double>& operator*=(const complex<_Tp>&);
1342 template<typename _Tp>
1343 complex<long double>& operator/=(const complex<_Tp>&);
1345 const _ComplexT& __rep() const { return _M_value; }
1352 complex<long double>::complex(long double __r, long double __i)
1354 __real__ _M_value = __r;
1355 __imag__ _M_value = __i;
1359 complex<long double>::real()
1360 { return __real__ _M_value; }
1362 inline const long double&
1363 complex<long double>::real() const
1364 { return __real__ _M_value; }
1367 complex<long double>::imag()
1368 { return __imag__ _M_value; }
1370 inline const long double&
1371 complex<long double>::imag() const
1372 { return __imag__ _M_value; }
1374 inline complex<long double>&
1375 complex<long double>::operator=(long double __r)
1377 __real__ _M_value = __r;
1378 __imag__ _M_value = 0.0L;
1382 inline complex<long double>&
1383 complex<long double>::operator+=(long double __r)
1385 __real__ _M_value += __r;
1389 inline complex<long double>&
1390 complex<long double>::operator-=(long double __r)
1392 __real__ _M_value -= __r;
1396 inline complex<long double>&
1397 complex<long double>::operator*=(long double __r)
1403 inline complex<long double>&
1404 complex<long double>::operator/=(long double __r)
1410 template<typename _Tp>
1411 inline complex<long double>&
1412 complex<long double>::operator=(const complex<_Tp>& __z)
1414 __real__ _M_value = __z.real();
1415 __imag__ _M_value = __z.imag();
1419 template<typename _Tp>
1420 inline complex<long double>&
1421 complex<long double>::operator+=(const complex<_Tp>& __z)
1423 __real__ _M_value += __z.real();
1424 __imag__ _M_value += __z.imag();
1428 template<typename _Tp>
1429 inline complex<long double>&
1430 complex<long double>::operator-=(const complex<_Tp>& __z)
1432 __real__ _M_value -= __z.real();
1433 __imag__ _M_value -= __z.imag();
1437 template<typename _Tp>
1438 inline complex<long double>&
1439 complex<long double>::operator*=(const complex<_Tp>& __z)
1442 __real__ __t = __z.real();
1443 __imag__ __t = __z.imag();
1448 template<typename _Tp>
1449 inline complex<long double>&
1450 complex<long double>::operator/=(const complex<_Tp>& __z)
1453 __real__ __t = __z.real();
1454 __imag__ __t = __z.imag();
1459 // These bits have to be at the end of this file, so that the
1460 // specializations have all been defined.
1461 // ??? No, they have to be there because of compiler limitation at
1462 // inlining. It suffices that class specializations be defined.
1464 complex<float>::complex(const complex<double>& __z)
1465 : _M_value(__z.__rep()) { }
1468 complex<float>::complex(const complex<long double>& __z)
1469 : _M_value(__z.__rep()) { }
1472 complex<double>::complex(const complex<float>& __z)
1473 : _M_value(__z.__rep()) { }
1476 complex<double>::complex(const complex<long double>& __z)
1477 : _M_value(__z.__rep()) { }
1480 complex<long double>::complex(const complex<float>& __z)
1481 : _M_value(__z.__rep()) { }
1484 complex<long double>::complex(const complex<double>& __z)
1485 : _M_value(__z.__rep()) { }
1488 #endif /* _GLIBCXX_COMPLEX */